package com.etime.shycourse.wx.applets.services.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.etime.shycourse.config.Tools;
import com.etime.shycourse.dto.CurrentUser;
import com.etime.shycourse.pojo.SysUser;
import com.etime.shycourse.wx.applets.dao.*;
import com.etime.shycourse.wx.applets.dto.CourseDetailsDto;
import com.etime.shycourse.wx.applets.dto.UserTeacherDto;
import com.etime.shycourse.wx.applets.pojo.*;
import com.etime.shycourse.wx.applets.services.interfaces.WxCourseDetailsServices;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @ClassName : WxCourseDetailsServiceImpl  //类名
 * @Description :  微信小程序 的课时详细  //描述
 * @Author : W //作者
 * @Date: 2022/1/4  9:44
 */
@Service
public class WxCourseDetailsServiceImpl implements WxCourseDetailsServices {
    @Autowired
    private CourseMapper mapper;
    @Autowired
    private Tools tools;

    @Autowired
    private LessonMapper lessonMapper;

    /**
     * 根据课程信息 里面的教师id 查询出教师信息
     *
     * @param courseteacherid Course表中 courseteacherid
     * @return UserTeacherDto
     */
    @Override
    public UserTeacherDto selectUserTeacherDtoById(Integer courseteacherid) {
        return mapper.selectUserTeacherDtoById (courseteacherid);
    }

    /**
     * 课程基本信息
     * <p>
     * 根据课程id 查询到 ”自己的“ 课程详细信息（课程类型信息+教师表+用户表+机构表+课程信息 +章节信息+课时信息+评论列表）
     * 教师表（教师简介，教师titile），用户表（教师姓名/nickname），机构表（机构名称，机构简介）；
     * 章节列表；课时列表；课程评论列表；
     * <p>
     * whetherToBuy 判定是否 有购买其订单中 包含其课程中的章节,给字段标识 whetherToBuy
     *
     * @param courseId
     * @return CourseDetailsDto
     */
    @Override
    public CourseDetailsDto selectCourseDetailsDtoSById(Integer courseId, String token) {
        CurrentUser user = tools.getCurrentUserFromRedis (token);
        //一个不存在的userid
        Integer userid = -10;
        if (user != null) {
            userid = user.getUser ().getUserid ();
        }
        // 返回的课程实体Dto
        CourseDetailsDto courseDetailsDto;
        // 查询出详细的课程  （教师表+用户表）+（课程类型）+（课程信息+章节+课时+视频）
        courseDetailsDto = mapper.selectChapterLessonAll (courseId, userid);
        // 用户信息
        if (user != null) {
            SysUser sysUser = user.getUser ();
            if (sysUser.getUserid () != null) {
                // 根据课程id 用户id 查出该课程相关 自己订单详情
                List<Orders> orders = mapper.selectOrgidsAllByUserIdCourseId (courseId, sysUser.getUserid ());
                courseDetailsDto.setOrderslist (orders);
            }
        }
        return courseDetailsDto;
    }

    /**
     * test 转换  ===》 按 课程 章节 课时购买则给出字段标识
     * 课程基本信息
     * <p>
     *
     * @param courseId
     * @return CourseDetailsDto
     */
    @Override
    public CourseDetailsDto selectCourseDetailsDtoSByIdConvert(Integer courseId, String token) {
        CurrentUser user = tools.getCurrentUserFromRedis (token);
        // 返回的课程实体Dto
        CourseDetailsDto dto;
        // 查询出详细的课程  （教师表+用户表）+（课程类型）+（课程信息+章节+课时+视频）
        dto = mapper.selectChapterLessonAll (courseId, 0);
        // 用户信息
        if (user != null) {
            SysUser sysUser = user.getUser ();
            if (sysUser.getUserid () != null) {
                //为课程是否购买进行 添加字段标识
                return Convert (dto, courseId, sysUser.getUserid ());
            }
        }
        return dto;
    }

    /**
     * 为课程是否购买进行 添加字段标识
     * <p></p>
     * <p>
     * 订单详情 --->（转换）---->课程添加字段标识
     */
    @Deprecated
    private CourseDetailsDto Convert(CourseDetailsDto dto, Integer courseId, Integer userId) {
        // 根据课程id 用户id 查出该课程相关 自己订单详情
        List<Orderdetail> list = mapper.selectOrderdetailAllByUserIdCourseId (courseId, userId);
        //按 课程 章节 课时购买则给出字段标识; odgoodstype 1--课程 2-- 章 '3--节' 4-- 课时
        for (Orderdetail l : list) {
            // 第一层 循环根据第一个 的订单详情 根据订单类型进行 判断购买课程类型
            // 类型在一个定单中必然（必须）存在！
            if (l.getOdgoodstype () == 1) {
                //  按课程购买  1--课程
                dto.setWhetherToBuy (1); //设置课程为购买
                break; //结束循环
            }
            if (l.getOdgoodstype () == 2) {
                //  按课程购买 2--章
                //  循环遍历 课程章
                for (Chapter chapter : dto.getChapters ()) {
                    // 循环遍历  自己订单详情 --->所有购买的 章id
                    list.forEach (ll -> {
                        Integer odchapterid = ll.getOdchapterid ();
                        if (chapter.getChapterid ().equals (odchapterid)) {
                            // 设置课程中的本章为 购买
                            chapter.setWhetherToBuy (1);
                        } else {
                            // 设置课程中的本章为 未购买
                            chapter.setWhetherToBuy (0);
                            // 有章节没有购买者代表课程 未购买
                            dto.setWhetherToBuy (0);
                        }
                    });
                }
                break; //结束循环
            }
            if (l.getOdgoodstype () == 4) {
                //  按课程课时购买 4--课时
                for (Chapter chapter : dto.getChapters ()) {
                    // 再遍历本课程 章中的 所有的课时
                    chapter.getLessons ().forEach (cha -> {
                        //自己订单详情 循环遍历 所有课时
                        list.forEach (ll -> {
                            // 课程 章节id
                            Integer odchapterid = ll.getOdchapterid ();
                            // 课程 课时id
                            Integer odlessonid = ll.getOdlessonid ();
                            if (chapter.getChapterid ().equals (odchapterid) && cha.getLessonid ().equals (odlessonid)) {
                                // 设置课程中的本课时为 购买
                                cha.setWhetherToBuy (1);
                            } else {
                                // 设置课程中的课时为 未购买
                                cha.setWhetherToBuy (0);
                                // 有章节没有购买者代表课程章节 未购买
                                chapter.setWhetherToBuy (0);
                            }
                        });
                    });
                    if (chapter.getWhetherToBuy () == 0) {
                        // 有章节没有购买者代表课程 未购买
                        dto.setWhetherToBuy (0);
                    }

                }
                break; //结束循环
            }
        }
        return dto;
    }

    /**
     * 微信
     * 根据课程id 用户id 查出改课程相关 订单id 订单on
     * 按用户 ID 课程 ID 获取订单
     *
     * @param courseId
     * @param token
     * @return Orders
     */
    @Override
    public Orders selectOrdersByUserIdCourseId(Integer courseId, String token) {
        CurrentUser user = tools.getCurrentUserFromRedis (token);
        // 根据token获取 用户信息
        if (user != null) {
            SysUser sysUser = user.getUser ();
            if (sysUser.getUserid () != null) {
                // 前期为了测试  避免前端重复下单 用List<Orders> 接受
                List<Orders> ordersList = mapper.selectOrdersByUserIdCourseId (courseId, sysUser.getUserid ());
                // 前期为了测试 返回list的第一个
                if (ordersList.size () > 0) {
                    return ordersList.get (0);
                }
            }
        }
        return null;
    }

    /**
     * 2022-02-25 15:58:37
     * 根据课时id 查询出课时的 标题 课程类型（文本
     * lessontitle
     * <p>
     * lessoncontent
     * 为了解决前端页面不好渲染问题
     * <p></p>
     *
     * @param lessonId
     * @return Lesson
     * @Author wb
     **/
    @Override
    public Lesson selectLessonById(Integer lessonId) {
        return lessonMapper.selectOne (new QueryWrapper<Lesson> ().eq ("lessonid", lessonId).select ("lessontitle", "lessoncontent"));
    }
}

